using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Windows.Forms.DataVisualization.Charting;
using Microsoft.Win32;
using System.Threading;
using System.Reflection;
using System.Diagnostics;
using System.IO;
using Fornax020.Devices;
using Fornax020.Configuration;
using Fornax020.Logging;
using Fornax020.SerialComm.Protocol;

namespace Fornax020.Forms
{
    /// <summary>
    /// @file MainForm.cs
    /// @brief 主窗体类
    /// @details X射线高压发生器控制软件的主界面，负责用户交互和界面更新
    /// 
    /// 设计模式应用：
    /// 1. 观察者模式：订阅设备状态变化事件
    /// 2. 依赖注入：通过构造函数注入设备管理器
    /// 3. 单一职责原则：专门负责UI逻辑，不处理业务逻辑
    /// 
    /// @author Fornax020 Development Team
    /// @date 2024
    /// @version 1.0.0
    /// </summary>
    public partial class MainForm : Form
    {
        #region 私有字段
        private readonly XRayGenerator _xRayGenerator;
        private readonly Logger _logger;
        private readonly ApplicationConfiguration _config;
        private readonly XRayDeviceConfig _deviceConfig;
        private bool _isClosing = false;
        
        // 防重复点击状态标志
        private bool _isClearingError = false;
        private bool _isSettingKv = false;
        private bool _isSettingMa = false;
        private bool _isStartingExposure = false;
        private bool _isStoppingExposure = false;
        #endregion


        #region 构造函数
        /// <summary>
        /// @brief 构造函数
        /// @details 初始化主窗体，设置设备管理器和事件订阅
        /// </summary>
        public MainForm()
        {
            InitializeComponent();

            // 初始化组件
            _logger = Logger.Instance;
            _config = ApplicationConfiguration.Instance;
            
            // 创建设备配置 - 支持从用户设置加载
            _deviceConfig = CreateDeviceConfig();
            
            // 使用配置创建设备管理器
            _xRayGenerator = new XRayGenerator(_deviceConfig);

            // 设置线程安全
            Control.CheckForIllegalCrossThreadCalls = false;
            
            // 订阅设备事件
            SubscribeToDeviceEvents();
            
            // 绑定设备状态
            BindToDeviceState();
            
            // 初始化界面
            InitializeUI();
            
            _logger.Info("MainForm initialized successfully with device config");
        }
        #endregion

        #region 配置管理
        /// <summary>
        /// @brief 创建设备配置
        /// @details 根据用户设置或默认值创建设备配置
        /// @return 设备配置对象
        /// </summary>
        private XRayDeviceConfig CreateDeviceConfig()
        {
            try
            {
                // 尝试从用户设置加载配置
                var userConfig = LoadUserDeviceConfig();
                if (userConfig != null)
                {
                    _logger.Info("Loaded user device configuration");
                    return userConfig;
                }
                
                // 使用默认配置
                _logger.Info("Using default device configuration");
                return XRayDeviceConfig.Default;
            }
            catch (Exception ex)
            {
                _logger.Warning($"Failed to load device config, using default: {ex.Message}");
                return XRayDeviceConfig.Default;
            }
        }

        /// <summary>
        /// @brief 加载用户设备配置
        /// @details 从应用程序配置中加载用户自定义的设备配置
        /// @return 用户配置或null
        /// </summary>
        private XRayDeviceConfig LoadUserDeviceConfig()
        {
            try
            {
                // 暂时使用默认配置，后续可以扩展用户配置加载
                return null;
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        /// @brief 保存设备配置
        /// @details 将当前设备配置保存到应用程序配置中
        /// </summary>
        private void SaveDeviceConfig()
        {
            try
            {
                // 暂时不保存配置，后续可以扩展配置保存功能
                _logger.Info("Device configuration save (placeholder)");
            }
            catch (Exception ex)
            {
                _logger.Warning($"Failed to save device config: {ex.Message}");
            }
        }
        #endregion

        #region 设备状态绑定
        /// <summary>
        /// @brief 绑定设备状态
        /// @details 绑定到设备状态属性，实现自动UI更新
        /// </summary>
        private void BindToDeviceState()
        {
            try
            {
                // 绑定状态变化事件
                _xRayGenerator.State.PropertyChanged += OnDeviceStatePropertyChanged;
                
                _logger.Info("Device state binding initialized");
            }
            catch (Exception ex)
            {
                _logger.Warning($"Failed to bind device state: {ex.Message}");
            }
        }

        /// <summary>
        /// @brief 设备状态属性变化事件处理
        /// @details 当设备状态属性发生变化时自动更新UI
        /// @param sender 事件发送者
        /// @param e 属性变化事件参数
        /// </summary>
        private void OnDeviceStatePropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            try
            {
                if (InvokeRequired)
                {
                    if (this.IsDisposed || this.Disposing) return;
                    Invoke(new System.ComponentModel.PropertyChangedEventHandler(OnDeviceStatePropertyChanged), sender, e);
                    return;
                }

                // 根据属性变化更新相应的UI控件
                switch (e.PropertyName)
                {
                    case nameof(XRayDeviceState.IsConnected):
                        UpdateConnectionUI(_xRayGenerator.IsConnected);
                        break;
                    case nameof(XRayDeviceState.IsExposing):
                        UpdateExposureUI(_xRayGenerator.IsExposing);
                        break;
                    case nameof(XRayDeviceState.FeedbackKv):
                        // 不自动更新KV显示，让具体指令处理
                        break;
                    case nameof(XRayDeviceState.FeedbackMa):
                        // 不自动更新MA显示，让具体指令处理
                        break;
                    case nameof(XRayDeviceState.FeedbackFil):
                        UpdateFilDisplay(_xRayGenerator.FeedbackFil);
                        break;
                    case nameof(XRayDeviceState.FirmwareVersion):
                        UpdateFirmwareDisplay(_xRayGenerator.FirmwareVersion);
                        break;
                    case nameof(XRayDeviceState.LastError):
                        UpdateErrorDisplay(_xRayGenerator.LastError);
                        break;
                }
            }
            catch (Exception ex)
            {
                HandleError($"状态属性变化处理异常: {ex.Message}", ex);
            }
        }
        #endregion

        #region 事件处理方法
        /// <summary>
        /// @brief 窗体加载事件处理
        /// @details 初始化串口列表和界面状态
        /// @param sender 事件发送者
        /// @param e 事件参数
        /// </summary>
        private void MainForm_Load(object sender, EventArgs e)
        {
            try
            {
                // 初始化串口列表
                RefreshSerialPorts();

                // 设置默认值
                SetDefaultValues();
                
                // 更新界面状态（确保按钮状态正确）
                UpdateUIState();
                
                _logger.Info("MainForm loaded successfully");
            }
            catch (Exception ex)
            {
                HandleError($"窗体加载失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// @brief 窗体关闭事件处理
        /// @details 清理资源并保存配置
        /// @param sender 事件发送者
        /// @param e 事件参数
        /// </summary>
        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            try
            {
                _isClosing = true;
                
                // 保存设备配置
                SaveDeviceConfig();
                
                // 断开设备连接
                if (_xRayGenerator.IsConnected)
                {
                    _xRayGenerator.Disconnect();
                }
                
                // 取消事件订阅
                UnsubscribeFromDeviceEvents();
                
                _logger.Info("MainForm closed successfully");
            }
            catch (Exception ex)
            {
                _logger.Error($"MainForm closing error: {ex.Message}", ex);
            }
        }
        #endregion

        #region 辅助方法
        /// <summary>
        /// @brief 订阅设备事件
        /// @details 订阅X射线设备的状态变化事件
        /// </summary>
        private void SubscribeToDeviceEvents()
        {
            _xRayGenerator.StatusChanged += OnDeviceStatusChanged;
            _xRayGenerator.ConnectionStatusChanged += OnDeviceConnectionStatusChanged;
            _xRayGenerator.ErrorOccurred += OnDeviceErrorOccurred;
            _xRayGenerator.ExposureStatusChanged += OnDeviceExposureStatusChanged;
        }

        /// <summary>
        /// @brief 统一错误处理
        /// @details 统一的错误处理策略
        /// @param message 错误消息
        /// @param exception 异常对象（可选）
        /// </summary>
        private void HandleError(string message, Exception exception = null)
        {
            try
            {
                _logger.Error(message, exception);
                ShowErrorMessage(message);
                
                // 如果启用了自动错误恢复
                if (_deviceConfig.EnableAutoErrorRecovery && !_isClosing)
                {
                    Task.Delay(_deviceConfig.ErrorRecoveryDelay).ContinueWith(_ =>
                    {
                        if (!_isClosing)
                        {
                            TryRecoverFromError();
                        }
                    });
                }
            }
            catch (Exception ex)
            {
                _logger.Error($"Error handling failed: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// @brief 尝试从错误中恢复
        /// @details 自动错误恢复策略
        /// </summary>
        private void TryRecoverFromError()
        {
            try
            {
                if (!_xRayGenerator.IsConnected)
                {
                    _logger.Info("Attempting to reconnect device");
                    // 可以尝试重新连接
                }
                else if (_xRayGenerator.State.HasError)
                {
                    _logger.Info("Attempting to clear device error");
                    _xRayGenerator.ClearError();
                }
            }
            catch (Exception ex)
            {
                _logger.Warning($"Error recovery failed: {ex.Message}");
            }
        }

        /// <summary>
        /// @brief 验证设备参数
        /// @details 使用设备配置验证参数
        /// @param kvValue KV值
        /// @param maValue MA值
        /// @return 验证结果
        /// </summary>
        private (bool isValid, string errorMessage) ValidateDeviceParameters(double kvValue, double maValue)
        {
            if (!_deviceConfig.IsValidKvValue(kvValue))
            {
                return (false, _deviceConfig.GetKvValueError(kvValue));
            }
            
            if (!_deviceConfig.IsValidMaValue(maValue))
            {
                return (false, _deviceConfig.GetMaValueError(maValue));
            }
            
            return (true, string.Empty);
        }
        #endregion

        #region UI更新方法
        /// <summary>
        /// @brief 更新KV显示
        /// @details 更新KV值显示
        /// @param kvValue KV值
        /// </summary>
        private void UpdateKvDisplay(double kvValue)
        {
            try
            {
                if (kvDisplayTextBox != null && !kvDisplayTextBox.IsDisposed)
                {
                    kvDisplayTextBox.Text = kvValue.ToString("F1");
                }
            }
            catch (Exception ex)
            {
                _logger.Warning($"Failed to update KV display: {ex.Message}");
            }
        }

        /// <summary>
        /// @brief 更新MA显示
        /// @details 更新MA值显示
        /// @param maValue MA值
        /// </summary>
        private void UpdateMaDisplay(double maValue)
        {
            try
            {
                if (maDisplayTextBox != null && !maDisplayTextBox.IsDisposed)
                {
                    maDisplayTextBox.Text = maValue.ToString("F0");
                }
            }
            catch (Exception ex)
            {
                _logger.Warning($"Failed to update MA display: {ex.Message}");
            }
        }

        /// <summary>
        /// @brief 更新FIL显示
        /// @details 更新FIL值显示
        /// @param filValue FIL值
        /// </summary>
        private void UpdateFilDisplay(double filValue)
        {
            try
            {
                // FIL显示暂时使用反馈文本框
                if (kvFeedbackTextBox != null && !kvFeedbackTextBox.IsDisposed)
                {
                    kvFeedbackTextBox.Text = filValue.ToString("F0");
                }
            }
            catch (Exception ex)
            {
                _logger.Warning($"Failed to update FIL display: {ex.Message}");
            }
        }

        /// <summary>
        /// @brief 更新固件版本显示
        /// @details 更新固件版本显示 - 简化版本，不在标题栏显示
        /// @param version 版本信息
        /// </summary>
        private void UpdateFirmwareDisplay(string version)
        {
            try
            {
                if (!string.IsNullOrEmpty(version))
                {
                    // 固件版本信息不再显示在标题栏中
                    // 可以在日志中记录固件版本信息
                    _logger.Info($"Firmware version: {version}");
                }
            }
            catch (Exception ex)
            {
                _logger.Warning($"Failed to update firmware display: {ex.Message}");
            }
        }

        /// <summary>
        /// @brief 更新错误显示
        /// @details 更新错误信息显示
        /// @param errorMessage 错误信息
        /// </summary>
        private void UpdateErrorDisplay(string errorMessage)
        {
            try
            {
                if (errorTextBox != null && !errorTextBox.IsDisposed)
                {
                    string errorDisplay = GetErrorDisplayText(errorMessage);
                    errorTextBox.Text = errorDisplay;
                }
            }
            catch (Exception ex)
            {
                _logger.Warning($"Failed to update error display: {ex.Message}");
            }
        }

        /// <summary>
        /// @brief 获取错误显示文本
        /// @details 将错误码转换为带中文解释的显示文本
        /// @param errorMessage 原始错误信息
        /// @return 带中文解释的错误信息
        /// </summary>
        private string GetErrorDisplayText(string errorMessage)
        {
            if (string.IsNullOrEmpty(errorMessage))
            {
                return string.Empty;
            }

            // 处理ER001格式的错误码（下位机实际发送格式）
            if (errorMessage.Length >= 5 && errorMessage.StartsWith("ER"))
            {
                string errorCode = errorMessage.Substring(2, 3);
                if (errorCode.All(char.IsDigit))
                {
                    // 使用ApplicationConfiguration中的错误码定义
                    string description = ApplicationConfiguration.ErrorCodeConfig.GetErrorDescription(errorCode);
                    return $"{errorMessage} - {description}";
                }
            }

            // 处理3位数字错误码（000-999）
            if (errorMessage.Length == 3 && errorMessage.All(char.IsDigit))
            {
                string description = ApplicationConfiguration.ErrorCodeConfig.GetErrorDescription(errorMessage);
                return $"{errorMessage} - {description}";
            }

            // 处理ProtocolConstants中的错误码（E01-E08）
            string protocolDescription = Fornax020.SerialComm.Protocol.ProtocolConstants.GetErrorDescription(errorMessage);
            if (!protocolDescription.StartsWith("未知错误"))
            {
                return $"{errorMessage} - {protocolDescription}";
            }

            // 如果都不匹配，直接返回原始错误信息
            return errorMessage;
        }

        /// <summary>
        /// @brief 测试错误码翻译功能
        /// @details 用于测试错误码翻译是否正常工作
        /// </summary>
        private void TestErrorCodeTranslation()
        {
            // 测试ER001格式的错误码（下位机实际发送格式）
            string[] erCodes = { "ER001", "ER002", "ER003", "ER004", "ER005", "ER006", "ER007", "ER008", "ER009", "ER010", "ER011", "ER012", "ER013", "ER014", "ER015", "ER016", "ER017", "ER018", "ER019" };
            _logger.Info("=== 下位机设备故障码测试 (ER001-ER019) ===");
            foreach (string code in erCodes)
            {
                string result = GetErrorDisplayText(code);
                _logger.Info($"错误码 '{code}' 翻译结果: {result}");
            }

            // 测试ProtocolConstants错误码（软件错误码）
            string[] protocolCodes = { "E01", "E02", "E03", "E04", "E05", "E06", "E07", "E08" };
            _logger.Info("=== 软件错误码测试 (E01-E08) ===");
            foreach (string code in protocolCodes)
            {
                string result = GetErrorDisplayText(code);
                _logger.Info($"错误码 '{code}' 翻译结果: {result}");
            }
        }

        private void ManualTestErrorCodeTranslation()
        {
            // 测试下位机设备故障码（ER001-ER019）
            string[] testCodes = { "ER001", "ER002", "ER003", "ER004", "ER005", "ER006", "ER007", "ER008", "ER009", "ER010", "ER011", "ER012", "ER013", "ER014", "ER015", "ER016", "ER017", "ER018", "ER019" };
            string testResult = "下位机设备故障码翻译测试:\n";
            
            foreach (string code in testCodes)
            {
                string result = GetErrorDisplayText(code);
                testResult += $"{result}\n";
            }
            
            errorTextBox.Text = testResult;
        }

        /// <summary>
        private void UpdateConnectionUI(bool isConnected)
        {
            try
            {
                // 更新打开/关闭串口按钮
                if (openSerialButton != null && !openSerialButton.IsDisposed)
                {
                    openSerialButton.Enabled = !isConnected;
                }
                
                if (closeSerialButton != null && !closeSerialButton.IsDisposed)
                {
                    closeSerialButton.Enabled = isConnected;
                }
                
                // 更新串口设置控件
                if (serialPortComboBox != null && !serialPortComboBox.IsDisposed)
                {
                    serialPortComboBox.Enabled = !isConnected;
                }
                
                if (baudRateComboBox != null && !baudRateComboBox.IsDisposed)
                {
                    baudRateComboBox.Enabled = !isConnected;
                }
                
                // 更新刷新按钮
                if (refreshButton != null && !refreshButton.IsDisposed)
                {
                    refreshButton.Enabled = !isConnected;
                }
                
                // 更新连接状态标签
                if (connectionStatusLabel != null && !connectionStatusLabel.IsDisposed)
                {
                    if (isConnected)
                    {
                        connectionStatusLabel.Text = "已连接";
                        connectionStatusLabel.ForeColor = Color.Green;
                    }
                    else
                    {
                        connectionStatusLabel.Text = "未连接";
                        connectionStatusLabel.ForeColor = Color.Red;
                    }
                }
                
                // 更新状态指示器
                if (statusIndicator != null && !statusIndicator.IsDisposed)
                {
                    if (isConnected)
                    {
                        statusIndicator.BackColor = Color.Green;
                    }
                    else
                    {
                        statusIndicator.BackColor = Color.Red;
                    }
                }
                
                _logger.Info($"连接状态UI已更新: {(isConnected ? "已连接" : "未连接")}");
            }
            catch (Exception ex)
            {
                _logger.Warning($"Failed to update connection UI: {ex.Message}");
            }
        }

        /// <summary>
        /// @brief 更新曝光状态UI
        /// @details 更新曝光状态相关的UI控件
        /// @param isExposing 是否正在曝光
        /// </summary>
        private void UpdateExposureUI(bool isExposing)
        {
            try
            {
                if (xrayOnButton != null && !xrayOnButton.IsDisposed)
                {
                    xrayOnButton.Enabled = !isExposing && _xRayGenerator.IsConnected;
                }
                
                if (xrayOffButton != null && !xrayOffButton.IsDisposed)
                {
                    xrayOffButton.Enabled = isExposing && _xRayGenerator.IsConnected;
                }
                
                // 标题栏现在是固定的，不需要更新
            }
            catch (Exception ex)
            {
                _logger.Warning($"Failed to update exposure UI: {ex.Message}");
            }
        }

        /// <summary>
        /// @brief 取消设备事件订阅
        /// @details 取消X射线设备的状态变化事件订阅
        /// </summary>
        private void UnsubscribeFromDeviceEvents()
        {
            try
            {
                if (_xRayGenerator != null)
                {
                    _xRayGenerator.StatusChanged -= OnDeviceStatusChanged;
                    _xRayGenerator.ConnectionStatusChanged -= OnDeviceConnectionStatusChanged;
                    _xRayGenerator.ErrorOccurred -= OnDeviceErrorOccurred;
                    _xRayGenerator.ExposureStatusChanged -= OnDeviceExposureStatusChanged;
                    _logger.Info("Device events unsubscribed successfully");
                }
            }
            catch (Exception ex)
            {
                _logger.Error($"Unsubscribe device events failed: {ex.Message}", ex);
            }
        }
        #endregion
        
        /// <summary>
        /// @brief 初始化界面
        /// @details 设置界面初始状态和默认值
        /// </summary>
        private void InitializeUI()
        {
            // 设置窗体标题
            this.Text = ApplicationConfiguration.UIConfig.APPLICATION_TITLE;
            
            // 设置默认值
            kvInputTextBox.Text = ApplicationConfiguration.DeviceConfig.DEFAULT_KV_VALUE.ToString();
            maInputTextBox.Text = ApplicationConfiguration.DeviceConfig.DEFAULT_MA_VALUE.ToString();
        }
        

        /// <summary>
        /// @brief 刷新串口列表
        /// @details 从系统注册表获取可用串口列表，并尝试恢复上次使用的串口
        /// </summary>
        private void RefreshSerialPorts()
        {
            try
            {
                RegistryKey keyCom = Registry.LocalMachine.OpenSubKey("Hardware\\DeviceMap\\SerialComm");
                if (keyCom != null)
                {
                    serialPortComboBox.Items.Clear();
                    string[] sSubKeys = keyCom.GetValueNames();
                    foreach (string sName in sSubKeys)
                    {
                        string sValue = (string)keyCom.GetValue(sName);
                        serialPortComboBox.Items.Add(sValue);
                    }
                }
                
                // 尝试恢复上次使用的串口
                RestoreLastUsedSerialPort();
                
                // 如果没有恢复成功，选择第一个可用串口
                if (serialPortComboBox.Items.Count > 0 && string.IsNullOrEmpty(serialPortComboBox.Text))
                {
                    serialPortComboBox.SelectedIndex = 0;
                }
                
                // 设置默认波特率
                if (baudRateComboBox.SelectedIndex == -1)
                {
                    baudRateComboBox.SelectedIndex = 1; // 默认选择9600
                }
            }
            catch (Exception ex)
            {
                _logger.Error($"Refresh serial ports failed: {ex.Message}", ex);
            }
        }
        
        /// <summary>
        /// @brief 恢复上次使用的串口
        /// @details 从配置中读取上次使用的串口信息并设置到界面
        /// </summary>
        private void RestoreLastUsedSerialPort()
        {
            try
            {
                string lastPortName = _config.LastUsedPortName;
                int lastBaudRate = _config.LastUsedBaudRate;
                
                // 如果配置中有上次使用的串口名称，且该串口在当前可用列表中
                if (!string.IsNullOrEmpty(lastPortName) && serialPortComboBox.Items.Contains(lastPortName))
                {
                    serialPortComboBox.Text = lastPortName;
                    _logger.Info($"恢复上次使用的串口: {lastPortName}");
                }
                
                // 恢复上次使用的波特率
                string baudRateText = lastBaudRate.ToString();
                if (baudRateComboBox.Items.Contains(baudRateText))
                {
                    baudRateComboBox.Text = baudRateText;
                    _logger.Info($"恢复上次使用的波特率: {lastBaudRate}");
                }
                else
                {
                    // 如果上次的波特率不在列表中，使用默认值
                    baudRateComboBox.SelectedIndex = 1; // 默认选择9600
                }
            }
            catch (Exception ex)
            {
                _logger.Error($"恢复上次使用的串口失败: {ex.Message}", ex);
            }
        }
        
        /// <summary>
        /// @brief 设置默认值
        /// @details 设置界面控件的默认值
        /// </summary>
        private void SetDefaultValues()
        {
            kvInputTextBox.Text = ApplicationConfiguration.DeviceConfig.DEFAULT_KV_VALUE.ToString();
            maInputTextBox.Text = ApplicationConfiguration.DeviceConfig.DEFAULT_MA_VALUE.ToString();
        }
        
        /// <summary>
        /// @brief 更新界面状态
        /// @details 根据设备连接状态更新界面控件状态
        /// </summary>
        private void UpdateUIState()
        {
            bool isConnected = _xRayGenerator.IsConnected;
            UpdateConnectionUI(isConnected);
        }

        /// <summary>
        /// @brief 验证串口参数
        /// @details 验证串口设置的有效性
        /// @return 验证结果
        /// </summary>
        private (bool isValid, string errorMessage) ValidateSerialPortSettings()
        {
            if (string.IsNullOrEmpty(serialPortComboBox.Text))
            {
                return (false, "请选择串口号");
            }

            if (!int.TryParse(baudRateComboBox.Text, out int baudRate) || baudRate <= 0)
            {
                return (false, "波特率必须是有效的正整数");
            }

            return (true, string.Empty);
        }

        /// <summary>
        /// @brief 验证KV输入
        /// @details 验证KV值输入的有效性
        /// @return 验证是否通过
        /// </summary>
        private bool ValidateKvInput()
        {
            if (string.IsNullOrWhiteSpace(kvInputTextBox.Text))
            {
                ShowErrorMessage("请输入KV值");
                kvInputTextBox.Focus();
                return false;
            }

            if (!double.TryParse(kvInputTextBox.Text, out double kvValue))
            {
                ShowErrorMessage("KV值格式错误，请输入有效的数字");
                kvInputTextBox.Focus();
                kvInputTextBox.SelectAll();
                return false;
            }

            if (kvValue < ApplicationConfiguration.DeviceConfig.MIN_KV_VALUE || 
                kvValue > ApplicationConfiguration.DeviceConfig.MAX_KV_VALUE)
            {
                ShowErrorMessage($"KV值超出范围，请输入{ApplicationConfiguration.DeviceConfig.MIN_KV_VALUE}-{ApplicationConfiguration.DeviceConfig.MAX_KV_VALUE}之间的数值");
                kvInputTextBox.Focus();
                kvInputTextBox.SelectAll();
                return false;
            }

            return true;
        }

        /// <summary>
        /// @brief 验证MA输入
        /// @details 验证MA值输入的有效性
        /// @return 验证是否通过
        /// </summary>
        private bool ValidateMaInput()
        {
            if (string.IsNullOrWhiteSpace(maInputTextBox.Text))
            {
                ShowErrorMessage("请输入MA值");
                maInputTextBox.Focus();
                return false;
            }

            if (!double.TryParse(maInputTextBox.Text, out double maValue))
            {
                ShowErrorMessage("MA值格式错误，请输入有效的数字");
                maInputTextBox.Focus();
                maInputTextBox.SelectAll();
                return false;
            }

            if (maValue < ApplicationConfiguration.DeviceConfig.MIN_MA_VALUE || 
                maValue > ApplicationConfiguration.DeviceConfig.MAX_MA_VALUE)
            {
                ShowErrorMessage($"MA值超出范围，请输入{ApplicationConfiguration.DeviceConfig.MIN_MA_VALUE}-{ApplicationConfiguration.DeviceConfig.MAX_MA_VALUE}之间的数值");
                maInputTextBox.Focus();
                maInputTextBox.SelectAll();
                return false;
            }

            return true;
        }

        /// <summary>
        /// @brief 显示成功消息
        /// @details 显示操作成功的消息
        /// @param message 消息内容
        /// </summary>
        private void ShowSuccessMessage(string message)
        {
            if (InvokeRequired)
            {
                Invoke(new Action<string>(ShowSuccessMessage), message);
                return;
            }

            MessageBox.Show(message, "操作成功", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
        
        /// <summary>
        /// @brief 检查设备连接状态
        /// @details 检查设备是否已连接，如果未连接则显示错误消息
        /// @return 是否已连接
        /// </summary>
        private bool CheckDeviceConnection()
        {
            if (!_xRayGenerator.IsConnected)
            {
                ShowErrorMessage("串口未连接，请先连接设备");
                return false;
            }
            return true;
        }
        
        /// <summary>
        /// @brief 显示错误消息
        /// @details 显示错误消息
        /// @param message 消息内容
        /// </summary>
        private void ShowErrorMessage(string message)
        {
            if (InvokeRequired)
            {
                Invoke(new Action<string>(ShowErrorMessage), message);
                return;
            }

            MessageBox.Show(message, "操作失败", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }




        /// <summary>
        /// @brief 打开串口按钮点击事件
        /// @details 连接到X射线设备
        /// @param sender 事件发送者
        /// @param e 事件参数
        /// </summary>
        private void openSerialButton_Click(object sender, EventArgs e)
        {
            try
            {
                // 防止重复点击
                if (_xRayGenerator.IsConnected)
                {
                    return;
                }
                
                // 验证串口参数
                var validation = ValidateSerialPortSettings();
                if (!validation.isValid)
                {
                    ShowErrorMessage(validation.errorMessage);
                    return;
                }

                // 获取串口参数
                string portName = serialPortComboBox.Text;
                int baudRate = int.Parse(baudRateComboBox.Text);

                // 同步执行连接操作
                bool success = _xRayGenerator.Connect(portName, baudRate);
                
                if (success)
                {
                    UpdateConnectionUI(true);
                    _logger.Info($"Device connected: {portName}, BaudRate: {baudRate}");
                    
                    // 保存成功连接的串口信息
                    _config.SaveSerialPortMemory(portName, baudRate);
                }
                else
                {
                    ShowErrorMessage("设备连接失败，请检查设备连接和参数设置");
                }
            }
            catch (Exception ex)
            {
                HandleError($"连接设备时发生错误: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// @brief 关闭串口按钮点击事件
        /// @details 断开与X射线设备的连接（异步执行，避免UI阻塞）
        /// @param sender 事件发送者
        /// @param e 事件参数
        /// </summary>
        private void closeSerialButton_Click(object sender, EventArgs e)
        {
            if (!_xRayGenerator.IsConnected) return;
            
            // 异步断开，避免阻塞UI线程
            Task.Run(() => _xRayGenerator.Disconnect());
        }








        #region 设备事件处理方法
        /// <summary>
        /// @brief 设备状态变化事件处理
        /// @details 处理设备状态变化，更新UI显示
        /// @param sender 事件发送者
        /// @param e 设备状态事件参数
        /// </summary>
        private void OnDeviceStatusChanged(object sender, DeviceStatusEventArgs e)
        {
            try
            {
                if (InvokeRequired)
                {
                    if (this.IsDisposed || this.Disposing) return;
                    Invoke(new EventHandler<DeviceStatusEventArgs>(OnDeviceStatusChanged), sender, e);
                    return;
                }

                System.Diagnostics.Debug.WriteLine($"[MainForm] OnDeviceStatusChanged: CommandType={e.CommandType}, FeedbackKv={e.FeedbackKv}, FeedbackMa={e.FeedbackMa}");
                _logger.Info($"设备状态变化: CommandType={e.CommandType}, FeedbackKv={e.FeedbackKv}, FeedbackMa={e.FeedbackMa}");

                // 根据命令类型更新不同的控件
                switch (e.CommandType)
                {
                    case "VP":
                        // VP指令(KV_FEEDBACK)显示在kvDisplayTextBox
                        kvDisplayTextBox.Text = e.FeedbackKv.ToString($"F{ApplicationConfiguration.DeviceConfig.KV_PRECISION}");
                        _logger.Info($"VP指令UI更新: kvDisplayTextBox设置为{e.FeedbackKv}");
                        break;
                        
                    case "CP":
                        // CP指令(MA_FEEDBACK)显示在maDisplayTextBox
                        maDisplayTextBox.Text = e.FeedbackMa.ToString($"F{ApplicationConfiguration.DeviceConfig.MA_PRECISION}");
                        _logger.Info($"CP指令UI更新: maDisplayTextBox设置为{e.FeedbackMa}");
                        break;
                        
                    case "MO":
                        // MO指令解析后只显示在反馈控件中
                        System.Diagnostics.Debug.WriteLine($"[MainForm] MO指令UI更新: KV={e.FeedbackKv}, MA={e.FeedbackMa}");
                        kvFeedbackTextBox.Text = e.FeedbackKv.ToString($"F{ApplicationConfiguration.DeviceConfig.KV_PRECISION}");
                        maFeedbackTextBox.Text = e.FeedbackMa.ToString($"F{ApplicationConfiguration.DeviceConfig.MA_PRECISION}");
                        _logger.Info($"MO指令UI更新: kvFeedbackTextBox设置为{e.FeedbackKv}, maFeedbackTextBox设置为{e.FeedbackMa}");
                        break;
                        
                    case "GR":
                        // 更新固件版本显示 - 不再更新标题栏
                        if (!string.IsNullOrEmpty(e.FirmwareVersion))
                        {
                            _logger.Info($"Firmware version received: {e.FirmwareVersion}");
                        }
                        break;
                        
                    case "ER":
                    case "ERROR":
                        // 更新错误显示，使用错误码翻译器
                        if (!string.IsNullOrEmpty(e.LastError))
                        {
                            string errorDisplay = GetErrorDisplayText(e.LastError);
                            errorTextBox.Text = errorDisplay;
                            _logger.Error($"设备错误: {errorDisplay}");
                        }
                        break;
                        
                    case "DEFAULT":
                        // 处理默认格式数据，通常不需要特殊处理
                        break;
                        
                    default:
                        // 未知指令类型，记录日志但不处理
                        _logger.Warning($"未知指令类型: {e.CommandType}");
                        break;
                }
                                            }
                                            catch (Exception ex)
                                            {
                _logger.Error($"Device status changed event failed: {ex.Message}", ex);
            }
        }
        
        /// <summary>
        /// @brief 设备连接状态变化事件处理
        /// @details 处理设备连接状态变化
        /// @param sender 事件发送者
        /// @param e 连接状态事件参数
        /// </summary>
        private void OnDeviceConnectionStatusChanged(object sender, ConnectionStatusEventArgs e)
                                            {
                                                try
                                                {
                if (InvokeRequired)
                {
                    if (this.IsDisposed || this.Disposing) return;
                    Invoke(new EventHandler<ConnectionStatusEventArgs>(OnDeviceConnectionStatusChanged), sender, e);
                    return;
                }

                UpdateConnectionUI(e.IsConnected);
                                                }
                                                catch (Exception ex)
                                                {
                _logger.Error($"Device connection status changed event failed: {ex.Message}", ex);
            }
        }
        
        /// <summary>
        /// @brief 设备错误事件处理
        /// @details 处理设备错误事件
        /// @param sender 事件发送者
        /// @param e 错误事件参数
        /// </summary>
        private void OnDeviceErrorOccurred(object sender, Fornax020.SerialComm.Protocol.ErrorEventArgs e)
        {
            try
            {
                if (InvokeRequired)
                {
                    if (this.IsDisposed || this.Disposing) return;
                    Invoke(new EventHandler<Fornax020.SerialComm.Protocol.ErrorEventArgs>(OnDeviceErrorOccurred), sender, e);
                    return;
                }

                _logger.Error($"Device error: {e.ErrorMessage}");
                string errorDisplay = GetErrorDisplayText(e.ErrorMessage);
                errorTextBox.Text = errorDisplay;
                                                 }
                                                 catch (Exception ex)
                                                 {
                _logger.Error($"Device error event failed: {ex.Message}", ex);
            }
        }
        
        /// <summary>
        /// @brief 设备曝光状态变化事件处理
        /// @details 处理设备曝光状态变化
        /// @param sender 事件发送者
        /// @param e 曝光状态事件参数
        /// </summary>
        private void OnDeviceExposureStatusChanged(object sender, ExposureStatusEventArgs e)
        {
            try
            {
                if (InvokeRequired)
                {
                    if (this.IsDisposed || this.Disposing) return;
                    Invoke(new EventHandler<ExposureStatusEventArgs>(OnDeviceExposureStatusChanged), sender, e);
                    return;
                }

                SetExposureIndicator(e.IsExposing);
            }
            catch (Exception ex)
            {
                _logger.Error($"Device exposure status changed event failed: {ex.Message}", ex);
            }
        }
        
        /// <summary>
        /// @brief 设置曝光指示器状态
        /// @details 根据曝光状态更新指示器颜色
        /// @param isExposing 是否正在曝光
        /// </summary>
        private void SetExposureIndicator(bool isExposing)
        {
            try
            {
                if (exposureIndicator != null && !exposureIndicator.IsDisposed)
                {
                    exposureIndicator.BackColor = isExposing ? Color.Yellow : Color.Gray;
                }
            }
            catch (Exception ex)
            {
                _logger.Error($"Set exposure indicator failed: {ex.Message}", ex);
            }
        }
        #endregion




        /// <summary>
        /// @brief 清除错误按钮点击事件
        /// @details 清除设备错误状态
        /// @param sender 事件发送者
        /// @param e 事件参数
        /// </summary>
        private void clearButton_Click(object sender, EventArgs e)
        {
            // 防重复点击保护
            if (_isClearingError) return;
            
            _isClearingError = true;
            clearButton.Enabled = false;
            
            // 无论是否连接，都先清除错误显示
            errorTextBox.Text = "";
            
            // 异步执行，避免阻塞UI线程（参考closeSerialButton的实现）
            Task.Run(() => {
                try
                {
                    if (_xRayGenerator.IsConnected)
                    {
                        bool success = _xRayGenerator.ClearError();
                        
                        // 在UI线程更新状态
                        this.Invoke(new Action(() => {
                            if (success)
                            {
                                _logger.Info("Error cleared");
                            }
                            else
                            {
                                _logger.Warning("Clear error command failed");
                            }
                        }));
                    }
                    else
                    {
                        this.Invoke(new Action(() => {
                            _logger.Info("Error display cleared (device not connected)");
                        }));
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() => {
                        _logger.Error($"Clear error failed: {ex.Message}", ex);
                        ShowErrorMessage($"清除错误时发生错误: {ex.Message}");
                    }));
                }
                finally
                {
                    this.Invoke(new Action(() => {
                        _isClearingError = false;
                        clearButton.Enabled = true;
                    }));
                }
            });
        }

        /// <summary>
        /// @brief KV输入框按键事件
        /// @details 只允许数字和小数点输入
        /// @param sender 事件发送者
        /// @param e 按键事件参数
        /// </summary>
        private void kvInputTextBox_KeyPress(object sender, KeyPressEventArgs e)
        {
            // 允许数字、小数点、退格键、删除键
            if (char.IsDigit(e.KeyChar) || e.KeyChar == '.' || e.KeyChar == (char)Keys.Back || e.KeyChar == (char)Keys.Delete)
            {
                // 如果输入的是小数点
                if (e.KeyChar == '.')
                {
                    // 检查是否已经有小数点了
                    if (kvInputTextBox.Text.Contains("."))
                    {
                        e.Handled = true; // 阻止输入
                    }
                }
                else
                {
                    e.Handled = false; // 允许输入
                }
            }
            else
            {
                e.Handled = true; // 阻止其他字符输入
            }
        }

        /// <summary>
        /// @brief KV输入框文本改变事件
        /// @details 验证输入内容，自动清理非法字符
        /// @param sender 事件发送者
        /// @param e 事件参数
        /// </summary>
        private void kvInputTextBox_TextChanged(object sender, EventArgs e)
        {
            // 如果输入包含非数字和非小数点的字符，自动清理
            string text = kvInputTextBox.Text;
            string cleanedText = "";
            
            for (int i = 0; i < text.Length; i++)
            {
                char c = text[i];
                if (char.IsDigit(c) || c == '.')
                {
                    cleanedText += c;
                }
            }
            
            // 如果有清理，更新文本框
            if (cleanedText != text)
            {
                kvInputTextBox.Text = cleanedText;
                kvInputTextBox.SelectionStart = cleanedText.Length; // 保持光标位置
            }
        }

        /// <summary>
        /// @brief 串口号下拉框点击事件
        /// @details 点击文本框也能打开下拉列表
        /// @param sender 事件发送者
        /// @param e 事件参数
        /// </summary>
        private void serialPortComboBox_Click(object sender, EventArgs e)
        {
            // 如果设备已连接，不允许修改
            if (_xRayGenerator.IsConnected)
            {
                ShowErrorMessage("设备已连接，无法修改串口号。请先断开设备连接。");
                return;
            }

            // 打开下拉列表
            serialPortComboBox.DroppedDown = true;
        }
        
        /// <summary>
        /// @brief 波特率下拉框点击事件
        /// @details 点击文本框也能打开下拉列表
        /// @param sender 事件发送者
        /// @param e 事件参数
        /// </summary>
        private void baudRateComboBox_Click(object sender, EventArgs e)
        {
            // 如果设备已连接，不允许修改
            if (_xRayGenerator.IsConnected)
            {
                ShowErrorMessage("设备已连接，无法修改波特率。请先断开设备连接。");
                    return;
                }
                
            // 打开下拉列表
            baudRateComboBox.DroppedDown = true;
        }

        /// <summary>
        /// @brief KV设置按钮点击事件
        /// @details 设置X射线管的KV值
        /// @param sender 事件发送者
        /// @param e 事件参数
        /// </summary>
        private void xrayOnButton_BUT_Click(object sender, EventArgs e)
        {
            // 防重复点击保护
            if (_isSettingKv) return;
            
            _isSettingKv = true;
            setKvButton.Enabled = false;
            
            // 异步执行，避免阻塞UI线程
            Task.Run(() => {
                try
                {
                    // 优先检查设备连接状态
                    if (!CheckDeviceConnection())
                    {
                        return;
                    }

                    // 验证输入
                    if (!ValidateKvInput())
                    {
                        return;
                    }

                    // 解析KV值
                    double kvValue = double.Parse(kvInputTextBox.Text);

                    // 使用配置验证参数
                    var validation = ValidateDeviceParameters(kvValue, 0);
                    if (!validation.isValid)
                    {
                        this.Invoke(new Action(() => {
                            ShowErrorMessage(validation.errorMessage);
                        }));
                        return;
                    }

                    // 使用设备管理器设置KV值
                    bool success = _xRayGenerator.SetKv(kvValue);

                    // 在UI线程更新状态
                    this.Invoke(new Action(() => {
                        if (success)
                        {
                            _logger.Info($"KV value set: {kvValue}");
                            // 等待设备VP响应来更新UI显示
                        }
                        else
                        {
                            ShowErrorMessage("KV值设置失败");
                        }
                    }));
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() => {
                        HandleError($"设置KV值时发生错误: {ex.Message}", ex);
                    }));
                }
                finally
                {
                    this.Invoke(new Action(() => {
                        _isSettingKv = false;
                        setKvButton.Enabled = true;
                    }));
                }
            });
        }

        /// <summary>
        /// @brief 窗体关闭事件处理
        /// @details 清理资源，确保程序正常退出
        /// @param sender 事件发送者
        /// @param e 事件参数
        /// </summary>
        private void MainForm_FormClosed(object sender, FormClosedEventArgs e)
        {
            try
            {
                _logger.Info("MainForm closed successfully");
                
                // 强制垃圾回收，确保资源释放
                GC.Collect();
                GC.WaitForPendingFinalizers();
                GC.Collect();
            }
            catch (Exception ex)
            {
                _logger.Error($"MainForm close failed: {ex.Message}", ex);
            }
        }




        /// <summary>
        /// @brief 停止曝光按钮点击事件
        /// @details 停止X射线曝光
        /// @param sender 事件发送者
        /// @param e 事件参数
        /// </summary>
        private void xrayOffButton_Click(object sender, EventArgs e)
        {
            try
            {
                // 优先检查设备连接状态
                if (!CheckDeviceConnection())
                {
                    return;
                }

                // 使用设备管理器停止曝光
                bool success = _xRayGenerator.StopExposure();
                
                if (success)
                {
                    _logger.Info("Exposure stopped");
                }
                else
                {
                    ShowErrorMessage("停止曝光失败");
                }
            }
            catch (Exception ex)
            {
                HandleError($"停止曝光时发生错误: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// @brief 开始曝光按钮点击事件
        /// @details 启动X射线曝光
        /// @param sender 事件发送者
        /// @param e 事件参数
        /// </summary>
        private void xrayOnButton_Click(object sender, EventArgs e)
        {
            try
            {
                // 优先检查设备连接状态
                if (!CheckDeviceConnection())
                {
                    return;
                }

                // 使用设备管理器开始曝光
                bool success = _xRayGenerator.StartExposure();
                
                if (success)
                {
                    _logger.Info("Exposure started");
                }
                else
                {
                    ShowErrorMessage("开始曝光失败");
                }
            }
            catch (Exception ex)
            {
                HandleError($"开始曝光时发生错误: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// @brief MA设置按钮点击事件
        /// @details 设置X射线管的MA值
        /// @param sender 事件发送者
        /// @param e 事件参数
        /// </summary>
        private void MA_Button_Click(object sender, EventArgs e)
        {
            // 防重复点击保护
            if (_isSettingMa) return;
            
            _isSettingMa = true;
            setMaButton.Enabled = false;
            
            // 异步执行，避免阻塞UI线程
            Task.Run(() => {
                try
                {
                    // 优先检查设备连接状态
                    if (!CheckDeviceConnection())
                    {
                        return;
                    }

                    // 验证输入
                    if (!ValidateMaInput())
                    {
                        return;
                    }

                    // 解析MA值
                    double maValue = double.Parse(maInputTextBox.Text);

                    // 使用配置验证参数
                    var validation = ValidateDeviceParameters(0, maValue);
                    if (!validation.isValid)
                    {
                        this.Invoke(new Action(() => {
                            ShowErrorMessage(validation.errorMessage);
                        }));
                        return;
                    }

                    // 使用设备管理器设置MA值
                    bool success = _xRayGenerator.SetMa(maValue);
                    
                    // 在UI线程更新状态
                    this.Invoke(new Action(() => {
                        if (success)
                        {
                            _logger.Info($"MA value set: {maValue}");
                        }
                        else
                        {
                            ShowErrorMessage("MA值设置失败");
                        }
                    }));
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() => {
                        HandleError($"设置MA值时发生错误: {ex.Message}", ex);
                    }));
                }
                finally
                {
                    this.Invoke(new Action(() => {
                        _isSettingMa = false;
                        setMaButton.Enabled = true;
                    }));
                }
            });
        }






        /// <summary>
        /// @brief 刷新串口按钮点击事件
        /// @details 刷新可用串口列表
        /// @param sender 事件发送者
        /// @param e 事件参数
        /// </summary>
        private void refreshButton_Click(object sender, EventArgs e)
        {
            try
            {
                // 如果设备已连接，不允许刷新
                if (_xRayGenerator.IsConnected)
                {
                    ShowErrorMessage("设备已连接，无法刷新串口列表。请先断开设备连接。");
                return;
            }

            // 保存当前选择的串口
            string currentPort = serialPortComboBox.Text;
            
            // 刷新串口列表
                RefreshSerialPorts();
            
            // 尝试恢复之前选择的串口
            if (!string.IsNullOrEmpty(currentPort) && serialPortComboBox.Items.Contains(currentPort))
            {
                serialPortComboBox.Text = currentPort;
            }
            
                _logger.Info("Serial port list refreshed");
            }
            catch (Exception ex)
            {
                _logger.Error($"Refresh serial ports failed: {ex.Message}", ex);
                ShowErrorMessage($"刷新串口列表时发生错误: {ex.Message}");
            }
        }

    }
}

